package com.common.utils.tool;

import cn.hutool.core.util.StrUtil;
import com.google.common.base.Charsets;
import com.common.utils.constant.Constants;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 描述：
 *  自定义字符串处理类
 *  <p>
 *      hutool(默认已经引入) guava common-lang3 已经将工具方法封装的非常完美了
 *      需要使用直接在pom里面添加依赖即可
 *  </p>
 * @author xianggj
 * @Date 2021/8/27 10:30
 **/
public class StringUtil extends StringUtils {

    /**
     * 包含多个字符串的判断
     * <p>
     *     1.3大工具类都不包含这个方法，故写一个
     *     2.如果想使用containAny
     *       可以调用{@link cn.hutool.core.util.StrUtil#containsAny(CharSequence, char...)}
     *
     * </p>
     * @param cs 源字符串
     * @param searchCharSequences 需要判断的数组
     * @return
     */
    public static boolean containAll(CharSequence cs, CharSequence... searchCharSequences) {
        if(!isEmpty(cs) && !ArrayUtils.isEmpty(searchCharSequences)) {
            CharSequence[] var2 = searchCharSequences;
            int var3 = searchCharSequences.length;

            for(int var4 = 0; var4 < var3; ++var4) {
                CharSequence searchCharSequence = var2[var4];
                if(!containsIgnoreCase(cs, searchCharSequence)) {
                    return false;
                }
            }

            return true;
        } else {
            return false;
        }
    }

    /**
     * 将ISO-8859-1 转为UTF8
     * @return
     */
    public static String convertIsoToUtf8(String data){
        try {
            String result = new String(data.getBytes(Charsets.ISO_8859_1), Charsets.UTF_8);
            return result;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return data;
    }

    /**
     * 将空对象转换为空字符串而不是null
     * <p>
     *     1.这个方法常用
     *     2.如果是字符串对象可以使用{@link StringUtils#trimToEmpty(String)}
     * </p>
     * @see StringUtils#defaultString(String)
     * @see String#valueOf(Object)
     * @code java.util.Objects.toString(Object, defaultValue)
     * @param object
     * @return
     */
    public static String toString(Object object) {
        return object == null? Constants.EMPTY : object.toString();
    }

    /**
     * 正则表达式字符串替换
     * @param content 字符串
     * @param pattern 正则表达式
     * @param newString 新的替换字符串
     * @return 返回替换后的字符串
     */
    public static String regReplace(String content,String pattern,String newString){
        if (isBlank(content) || isBlank(pattern)){
            return content;
        }
        Pattern p = Pattern.compile(pattern);
        Matcher m = p.matcher(content);
        String result = m.replaceAll(newString);
        return result;
    }

    /**
     * 字符前N个字符相同
     * @param str
     * @param prefix
     * @param start
     * @return
     */
    public static boolean startWithToN(CharSequence str, CharSequence prefix, int start){
            if (StrUtil.isEmpty(str) || StrUtil.isEmpty(prefix)){
                return false;
            }
        String sub1 = StrUtil.sub(str, 0, start);
        String sub2 = StrUtil.sub(prefix, 0, start);
        return sub1.equals(sub2);
    }

    /**
     * 字符后N个字符相同
     * @param str
     * @param prefix
     * @param end
     * @return
     */
    public static boolean endWithToN(CharSequence str, CharSequence prefix, int end){
        if (StrUtil.isEmpty(str) || StrUtil.isEmpty(prefix)){
            return false;
        }
        String sub1 = StrUtil.sub(str, str.length() - end, str.length());
        String sub2 = StrUtil.sub(prefix, prefix.length() - end, prefix.length());
        return sub1.equals(sub2);
    }

    /**
     * json中的空
     * @param str
     * @return
     */
    public static boolean isJsonBlank(CharSequence str) {
        if (StrUtil.isBlank(str)){
            return true;
        }
        if (StrUtil.equalsIgnoreCase(Constants.UNDEFINED, str)){
            return true;
        }
        if (StrUtil.equalsIgnoreCase(Constants.NULL, str)){
            return true;
        }
        if (StrUtil.equalsIgnoreCase(Constants.OBJECT_NULL, str)){
            return true;
        }
        if (StrUtil.equalsIgnoreCase(Constants.ARRAY_NULL, str)){
            return true;
        }
        return false;
    }

}
